package com.dudu.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.BeanUtils;

import com.dudu.bean.ChargingRuleBean;
import com.dudu.bean.ParamBean;
import com.dudu.bean.RuleAccountBean;
import com.dudu.bean.ZTreeBean;
import com.dudu.dao.CharginRuleDao;
import com.dudu.model.ChargingRule;
import com.dudu.model.RuleAccount;
import com.dudu.service.IRuleService;

import core.CoreDao;
import core.CoreDaoInvoke;

/**
 * 能力规则设置实现类
 * 
 * @author 危东
 * @date 2016-4-26
 */
public class RuleServiceImpl implements IRuleService {

    private static final Logger log = core.util.Logger.getLogger(RuleServiceImpl.class.getSimpleName());
    private CharginRuleDao charginRuleDao = new CharginRuleDao();
    private CoreDao coreDao = CoreDaoInvoke.getInstance();

    /**
     * 插入规则信息
     * 
     * @param bean
     * @return
     */
    public String doInsertChargingRule(ChargingRuleBean bean) {
	int result = -1;
	result = charginRuleDao.insertChargingRule(coreDao, conversion(bean));
	return result + "";
    }

    /**
     * 修改规则信息
     * 
     * @param bean
     * @return
     */
    public String doUpdateChargingRule(ChargingRuleBean bean) {
	return charginRuleDao.updateChargingRule(coreDao, conversion(bean)) + "";
    }

    /**
     * 根据AppKey、账号标识和能力类型查询配置
     * 
     * @param dao
     * @param appKey
     * @param custAccount
     * @param ruleType
     * @return
     */
    @Override
    public ChargingRuleBean queryChargingRule(String appKey, String custAccount, String ruleType) {
	log.info("RuleServiceImpl.queryChargingRule 根据AppKey、账号标识和能力类型查询配置");
	// 最终返回的
	ChargingRuleBean result = new ChargingRuleBean();
	// 根据AppKey、账号标识查询账号配置的能力规则信息
	ChargingRule chargingRule = new ChargingRule();
	// 查询计费账号的能力配置
	chargingRule = charginRuleDao.queryDefAbilityByAccIdAndType(coreDao, appKey, custAccount, ruleType);
	// 判断查询的配置是否正确，如果未查到，则查询其父级配置（应用配置）
	if (chargingRule != null) {
	    // 转换实体类
	    BeanUtils.copyProperties(chargingRule, result);
	} else {
	    // 判断如果custAccount不是-1，则查询的是账号的配置，如果是-1，则之前查询的为应用的配置
	    if (!custAccount.equals("-1")) {
		// 根据账号ID查询账号配置的能力规则信息
		// 查询应用标识查询能力配置
		ChargingRule chargingRule1 = new ChargingRule();
		chargingRule1 = charginRuleDao.queryDefAbilityByAccIdAndType(coreDao, appKey, "-1", ruleType);
		// 获取数据
		if (chargingRule1 != null) {
		    // 转换实体类
		    BeanUtils.copyProperties(chargingRule1, result);
		} else {
		    // 获取系统默认配置
		    ChargingRule chargingRuleDef = new ChargingRule();
		    chargingRuleDef = charginRuleDao.queryRuleByParentType(coreDao, ruleType);
		    if (chargingRuleDef == null) {
			return null;
		    }
		    BeanUtils.copyProperties(chargingRuleDef, result);
		}
	    } else {
		// 获取系统默认配置
		ChargingRule chargingRuleDef = new ChargingRule();
		chargingRuleDef = charginRuleDao.queryRuleByParentType(coreDao, ruleType);
		if (chargingRuleDef == null) {
		    return null;
		}
		BeanUtils.copyProperties(chargingRuleDef, result);
	    }
	}
	return result;
    }

    /**
     * 查询规则信息
     * 
     * @return
     */
    public List<ChargingRuleBean> queryAllRuleByAppCust(String appkey, String custAccount) {
	// 查询所有的
	List<ChargingRule> list = new ArrayList<ChargingRule>();
	list = charginRuleDao.queryAllRule(coreDao, "", "");
	// 给数据排序
	List<ChargingRuleBean> listSort = new ArrayList<ChargingRuleBean>();
	int tId = 0;// 获取id值
	int iparentId = 0;// 获取外层循环的parent_id值
	int jparentId = 0;// 获取内层循环的parent_id值
	// 用于判断能力数量
	int abilityNum = 0;
	// 按所需的顺序排列数据
	for (int i = 0; i < list.size(); i++) {
	    tId = list.get(i).getId();
	    iparentId = list.get(i).getParent_id();
	    String menu_type = list.get(i).getMenu_type();
	    // 判断如果类型是“能力”类型，则数量+1
	    if ("ability".equals(menu_type)) {
		abilityNum++;
	    }
	    if (iparentId == -1) {
		// 如果parent_id为-1，则先插入listSort
		listSort.add(conversion(list.get(i)));
		for (int j = 0; j < list.size(); j++) {
		    // 然后将该parent_id为-1的数据中的id与其他数据的parent_id匹配
		    jparentId = list.get(j).getParent_id();
		    if (tId == jparentId) {
			// 若相等，则插入listSort
			listSort.add(conversion(list.get(j)));
		    }
		}

	    }
	}
	// 已配置的数据
	List<RuleAccount> ruleAccountList = this.charginRuleDao.queryRuleByAppAndAccount(coreDao, appkey, custAccount);
	return editList(listSort, ruleAccountList);
    }

    /**
     * 处理规则信息，将配置的能力规则数据传入规则信息实体类list
     * 
     * @param ruleList
     * @param ruleAccountList
     * @return
     */
    private List<ChargingRuleBean> editList(List<ChargingRuleBean> ruleList, List<RuleAccount> ruleAccountList) {
	// 最终返回的数据
	List<ChargingRuleBean> ruleListResult = new ArrayList<ChargingRuleBean>();
	for (int i = 0; i < ruleList.size(); i++) {
	    // 获取能力配置信息
	    ChargingRuleBean chargingRule = ruleList.get(i);// list
	    // 遍历查询所有配置的信息
	    chargingRule.setDefault_using("no");
	    for (int j = 0; j < ruleAccountList.size(); j++) {
		RuleAccount ruleAccount = ruleAccountList.get(j);// 已配置的list
		// 判断如果配置信息中的能力id等于能力id，则将单价信息插入list中
		if (ruleAccount.getRule_id() == chargingRule.getId()) {
		    chargingRule.setDefault_using("yes");
		    break;
		}
	    }
	    ruleListResult.add(chargingRule);
	}
	return ruleListResult;
    }

    /**
     * 根据父能力标识删除某应用/计费账号下的规则
     * 
     * @param app_key
     * @param cust_account
     * @param type
     *            父节点type
     * @return
     */
    public int deleteRuleAccouunt(String app_key, String cust_account, String type) {
	int result = -1;
	ChargingRule parentRule = charginRuleDao.queryByType(coreDao, type);
	List<ChargingRule> childrenRuleList = charginRuleDao.queryByParentId(coreDao, parentRule.getId() + "");
	if (childrenRuleList != null) {
	    for (ChargingRule childrenRule : childrenRuleList) {
		int t = charginRuleDao.deleteChargingRule(coreDao, app_key, cust_account, childrenRule.getId() + "");
		if (t > 0) {
		    return t;
		}
	    }
	}
	return result;
    }

    /**
     * 通过应用账号更改组织账号中的“默认使用”，全部更改为所需要的配置
     * 
     * @param jsonList
     * @return
     */
    public String doDeleteChargingRule(List<RuleAccountBean> beanList) {
	log.info("RuleServiceImpl.doDeleteChargingRule");
	// 最终返回结果
	int result = -1;
	// 判断如果传入的list不为空并且数量大于零，则获取第一条数据的账号id进行删除操作
	if (!beanList.isEmpty()) {
	    if (beanList.size() > 0) {
		RuleAccountBean bean = beanList.get(0);
		// 通过应用账号更改组织账号中的“默认使用”，全部更改为所需要的配置
		result = charginRuleDao.deleteChargingRule(coreDao, bean.getApp_key(), null, null);
	    }
	}
	return result + "";
    }

    /**
     * 插入账号-能力规则关系数据，方法中统一，先根据账号id删除相应对应关系，后进行插入操作
     * 
     * @param jsonList
     * @return
     */
    public String doRuleAccountInsert(List<RuleAccountBean> beanList) {
	log.info("RuleServiceImpl.doRuleAccountInsert");
	int resultDelete = -1;
	// 最终返回结果
	int result = -1;
	// 判断如果传入的list不为空并且数量大于零，则获取第一条数据的账号id进行删除操作
	if (!beanList.isEmpty()) {
	    if (beanList.size() > 0) {
		RuleAccountBean bean = beanList.get(0);
		if (StringUtils.isNotBlank(bean.getCust_account())) {
		    // 先根据账号id删除相应的对照关系
		    resultDelete = charginRuleDao.deleteChargingRule(coreDao, bean.getApp_key(), bean.getCust_account(), null);
		    // 判断如果删除成功，则进行下面的添加操作
		    if (resultDelete != -1) {
			for (int i = 0; i < beanList.size(); i++) {
			    RuleAccountBean beans = beanList.get(i);
			    if (beans.getDefault_using().equals("yes")) {
				result = charginRuleDao.insertRuleAccount(coreDao, conversion(beans));
			    }

			}
		    }
		}

	    }
	}

	return result + "";
    }

    /**
     * 查询规则信息总数量
     * 
     * @param paramSql
     * @return
     */
    public int getTotalRule(String paramSql) {
	return charginRuleDao.getTotalRule(coreDao, paramSql);
    }

    /**
     * 查询所有规则信息，并转换成所需的ztree格式
     * 
     * @param pageSql
     * @param paramSql
     * @return
     */
    public List<ChargingRuleBean> queryRule(String pageSql, String paramSql) {
	// 查询结果
	List<ChargingRule> list = new ArrayList<ChargingRule>();
	// 获取查询结果
	list = charginRuleDao.queryAllRule(coreDao, pageSql, paramSql);
	List<ChargingRuleBean> listSort = new ArrayList<ChargingRuleBean>();
	int tId = 0;// 获取id值
	int iparentId = 0;// 获取外层循环的parent_id值
	int jparentId = 0;// 获取内层循环的parent_id值
	// 按所需的顺序排列数据
	for (int i = 0; i < list.size(); i++) {
	    tId = list.get(i).getId();
	    iparentId = list.get(i).getParent_id();
	    if (iparentId == -1) {
		// 如果parent_id为-1，则先插入listSort
		listSort.add(conversion(list.get(i)));
		for (int j = 0; j < list.size(); j++) {
		    // 然后将该parent_id为-1的数据中的id与其他数据的parent_id匹配
		    jparentId = list.get(j).getParent_id();
		    if (tId == jparentId) {
			// 若相等，则插入listSort
			listSort.add(conversion(list.get(j)));
		    }
		}

	    }
	}

	return listSort;

    }

    /**
     * 设置默认选项
     * 
     * @param id
     * @return
     */
    public int doEditDefaultUsing(String id) {
	ChargingRule rule = new ChargingRule();
	rule.setId(Integer.parseInt(id));
	int result = -1;
	int result1 = -1;
	int result2 = -1;
	result1 = charginRuleDao.updateByRadiobtnNo(coreDao, rule);
	result2 = charginRuleDao.updateDefaultUsing(coreDao, rule);
	if (result1 != -1 && result2 != -1) {
	    result = 0;
	}
	return result;
    }

    /**
     * 查询所有规则信息，并转换成所需的ztree格式
     * 
     * @param pageSql
     * @param paramSql
     * @return
     */
    public List<ZTreeBean> queryAllRule(String pageSql, String paramSql) {
	// 查询结果
	List<ChargingRule> list = new ArrayList<ChargingRule>();
	// 获取所有的计费规则
	list = charginRuleDao.queryAllRule(coreDao, pageSql, paramSql);
	// 存放返回值
	List<ZTreeBean> listSort = new ArrayList<ZTreeBean>();
	int tId = 0;// 获取id值
	int iparentId = 0;// 获取外层循环的parent_id值
	int jparentId = 0;// 获取内层循环的parent_id值

	int xId = 1;// 设置ztree的父节点id值
	int yId = 1;// 设置ztree的子节点id值：xId*10+yId

	// 按所需的顺序排列数据
	for (int i = 0; i < list.size(); i++) {
	    ZTreeBean tree = new ZTreeBean();
	    ChargingRule chargingRule = new ChargingRule();
	    chargingRule = list.get(i);
	    tId = chargingRule.getId();
	    iparentId = chargingRule.getParent_id();

	    // 判断是否为父节点
	    if (iparentId == -1) {
		// 如果parent_id为-1，则先插入listSort
		tree.setId(xId);
		tree.setpId(0);
		tree.setName(chargingRule.getNames());// 存储能力类型的名称
		tree.setRemarks(chargingRule.getType());// 存储能力类型的标识
		listSort.add(tree);
		for (int j = 0; j < list.size(); j++) {
		    ZTreeBean tree2 = new ZTreeBean();
		    chargingRule = list.get(j);
		    // 然后将该parent_id为-1的数据中的id与其他数据的parent_id匹配
		    jparentId = chargingRule.getParent_id();
		    if (tId == jparentId) {
			// 若相等，则插入listSort
			tree2.setId(xId * 10 + yId);
			tree2.setpId(xId);
			tree2.setName(chargingRule.getNames());// 存储能力类型的名称
			tree2.setRemarks(chargingRule.getType());// 存储能力类型的标识
			listSort.add(tree2);

			yId++;
		    }
		}
		xId++;
		yId = 1;// 重置为1
	    }
	}

	return listSort;
    }

    /**
     * 查询所有父节点信息列表
     * 
     * @param parentId
     * @return
     */
    public List<ParamBean> queryAllParentId(String parentId) {
	return charginRuleDao.queryAllParentId(coreDao);
    }

    /**
     * 转化
     * 
     * @param menu
     * @return
     */
    private RuleAccountBean conversion(RuleAccount bean) {
	RuleAccountBean ruleAccountBean = new RuleAccountBean();
	BeanUtils.copyProperties(bean, ruleAccountBean);// 源,目的
	// PropertyUtils.copyProperties(dest, orig);//目的,源
	return ruleAccountBean;
    }

    /**
     * 转化
     * 
     * @param menuBean
     * @return
     */
    private RuleAccount conversion(RuleAccountBean bean) {
	RuleAccount account = new RuleAccount();
	BeanUtils.copyProperties(bean, account);// 源,目的
	// PropertyUtils.copyProperties(dest, orig);//目的,源
	return account;
    }

    /**
     * 转化
     * 
     * @param menu
     * @return
     */
    private ChargingRuleBean conversion(ChargingRule bean) {
	ChargingRuleBean chargingRuleBean = new ChargingRuleBean();
	BeanUtils.copyProperties(bean, chargingRuleBean);// 源,目的
	// PropertyUtils.copyProperties(dest, orig);//目的,源
	return chargingRuleBean;
    }

    /**
     * 转化
     * 
     * @param menuBean
     * @return
     */
    private ChargingRule conversion(ChargingRuleBean bean) {
	ChargingRule rule = new ChargingRule();
	BeanUtils.copyProperties(bean, rule);// 源,目的
	// PropertyUtils.copyProperties(dest, orig);//目的,源
	return rule;
    }
}
